// Copyright 2013 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

#include "url/url_canon.h"
#include "url/url_canon_internal.h"

// Query canonicalization in IE
// ----------------------------
// IE is very permissive for query parameters specified in links on the page
// (in contrast to links that it constructs itself based on form data). It does
// not unescape any character. It does not reject any escape sequence (be they
// invalid like "%2y" or freaky like %00).
//
// IE only escapes spaces and nothing else. Embedded NULLs, tabs (0x09),
// LF (0x0a), and CR (0x0d) are removed (this probably happens at an earlier
// layer since they are removed from all portions of the URL). All other
// characters are passed unmodified. Invalid UTF-16 sequences are preserved as
// well, with each character in the input being converted to UTF-8. It is the
// server's job to make sense of this invalid query.
//
// Invalid multibyte sequences (for example, invalid UTF-8 on a UTF-8 page)
// are converted to the invalid character and sent as unescaped UTF-8 (0xef,
// 0xbf, 0xbd). This may not be canonicalization, the parser may generate these
// strings before the URL handler ever sees them.
//
// Our query canonicalization
// --------------------------
// We escape all non-ASCII characters and control characters, like Firefox.
// This is more conformant to the URL spec, and there do not seem to be many
// problems relating to Firefox's behavior.
//
// Like IE, we will never unescape (although the application may want to try
// unescaping to present the user with a more understandable URL). We will
// replace all invalid sequences (including invalid UTF-16 sequences, which IE
// doesn't) with the "invalid character," and we will escape it.

namespace url {

namespace {

    // Returns true if the characters starting at |begin| and going until |end|
    // (non-inclusive) are all representable in 7-bits.
    template <typename CHAR, typename UCHAR>
    bool IsAllASCII(const CHAR* spec, const Component& query)
    {
        int end = query.end();
        for (int i = query.begin; i < end; i++) {
            if (static_cast<UCHAR>(spec[i]) >= 0x80)
                return false;
        }
        return true;
    }

    // Appends the given string to the output, escaping characters that do not
    // match the given |type| in SharedCharTypes. This version will accept 8 or 16
    // bit characters, but assumes that they have only 7-bit values. It also assumes
    // that all UTF-8 values are correct, so doesn't bother checking
    template <typename CHAR>
    void AppendRaw8BitQueryString(const CHAR* source, int length,
        CanonOutput* output)
    {
        for (int i = 0; i < length; i++) {
            if (!IsQueryChar(static_cast<unsigned char>(source[i])))
                AppendEscapedChar(static_cast<unsigned char>(source[i]), output);
            else // Doesn't need escaping.
                output->push_back(static_cast<char>(source[i]));
        }
    }

    // Runs the converter on the given UTF-8 input. Since the converter expects
    // UTF-16, we have to convert first. The converter must be non-NULL.
    void RunConverter(const char* spec,
        const Component& query,
        CharsetConverter* converter,
        CanonOutput* output)
    {
        // This function will replace any misencoded values with the invalid
        // character. This is what we want so we don't have to check for error.
        RawCanonOutputW<1024> utf16;
        ConvertUTF8ToUTF16(&spec[query.begin], query.len, &utf16);
        converter->ConvertFromUTF16(utf16.data(), utf16.length(), output);
    }

    // Runs the converter with the given UTF-16 input. We don't have to do
    // anything, but this overridden function allows us to use the same code
    // for both UTF-8 and UTF-16 input.
    void RunConverter(const base::char16* spec,
        const Component& query,
        CharsetConverter* converter,
        CanonOutput* output)
    {
        converter->ConvertFromUTF16(&spec[query.begin], query.len, output);
    }

    template <typename CHAR, typename UCHAR>
    void DoConvertToQueryEncoding(const CHAR* spec,
        const Component& query,
        CharsetConverter* converter,
        CanonOutput* output)
    {
        if (IsAllASCII<CHAR, UCHAR>(spec, query)) {
            // Easy: the input can just appended with no character set conversions.
            AppendRaw8BitQueryString(&spec[query.begin], query.len, output);

        } else {
            // Harder: convert to the proper encoding first.
            if (converter) {
                // Run the converter to get an 8-bit string, then append it, escaping
                // necessary values.
                RawCanonOutput<1024> eight_bit;
                RunConverter(spec, query, converter, &eight_bit);
                AppendRaw8BitQueryString(eight_bit.data(), eight_bit.length(), output);

            } else {
                // No converter, do our own UTF-8 conversion.
                AppendStringOfType(&spec[query.begin], query.len, CHAR_QUERY, output);
            }
        }
    }

    template <typename CHAR, typename UCHAR>
    void DoCanonicalizeQuery(const CHAR* spec,
        const Component& query,
        CharsetConverter* converter,
        CanonOutput* output,
        Component* out_query)
    {
        if (query.len < 0) {
            *out_query = Component();
            return;
        }

        output->push_back('?');
        out_query->begin = output->length();

        DoConvertToQueryEncoding<CHAR, UCHAR>(spec, query, converter, output);

        out_query->len = output->length() - out_query->begin;
    }

} // namespace

void CanonicalizeQuery(const char* spec,
    const Component& query,
    CharsetConverter* converter,
    CanonOutput* output,
    Component* out_query)
{
    DoCanonicalizeQuery<char, unsigned char>(spec, query, converter,
        output, out_query);
}

void CanonicalizeQuery(const base::char16* spec,
    const Component& query,
    CharsetConverter* converter,
    CanonOutput* output,
    Component* out_query)
{
    DoCanonicalizeQuery<base::char16, base::char16>(spec, query, converter,
        output, out_query);
}

void ConvertUTF16ToQueryEncoding(const base::char16* input,
    const Component& query,
    CharsetConverter* converter,
    CanonOutput* output)
{
    DoConvertToQueryEncoding<base::char16, base::char16>(input, query,
        converter, output);
}

} // namespace url
